// 智能表单 个体配置中，可以配置默认值。
// 然后，判断初始化地址，如果存在，加载初始化值（比如，修改，从服务器访问取数据）
function NW06_gt(nw, nwDJ) {
    this.nw = nw;
    this.nwJD = nwDJ;
    this.jd = nwDJ.Jiedian;               
    this.znbd = this.hqZnbd()
    this.zt = 0;//表单状态，0=校验不通过；1=检验通过;

    //智能表单的节点集合
    this.jdM = [];
    this._ngj_hqKJ(this.jd);

    //表单里面的控件
    this.kjM = [];
    this.pz = null;
    //表单的数据保存在哪里（服务器后台）
    this.yc_dizhi;
    //从远程内容中，提取数据的关键词（属性名）
    this.yc_shuju_dizhi = 'dizhi';      //表单的数据要提交到哪个服务器路径 
    this.yc_shuju_cs = 'cs';            //附上的参数
    this.yc_shuju_gt = 'gt';            //个体参数 默认值、校验规则、提示信息、 如果控件是文件，还包括 上传文件的路径
    this.yc_shuju_kj_dizhi = 'kj_dizhi' //针对【控件】的文件上传的地址。

    this.zdc = nw.ck.tcc.dedai('正在准备，请稍后......', this.nwJD, 1);//锁屏body
    this.sj = null;//在方法 _03yc_qq_cg 里面初始化 new NW06_gt_sj(this);

    this.qd0()
}

//点击上传按键时，会自动调用这个方法
NW06_gt.prototype.sq = function () {
    this.zdc.xs()
}

//点击重置按键时，会自动调用这个方法
NW06_gt.prototype.cz = function () {

}

NW06_gt.prototype.qd0 = function () {
    let pz = this._ngj_hqSXzhi('pz');
    if (pz) {
        this.jiazaiPZ(eval(pz));
    } else {
        pz = this._ngj_hqSXzhi('pz2');
        if (pz) {
            let fwfs = this._ngj_hqSXzhi('fwfs');
            this.jiazaiPZ(pz, fwfs ? fwfs : 'get');
        }
    }
}

/**
 * 1、加载配置
 * @param {文本|对象} dizhi_dx 地址|对象
 * @param {文本} fwfs 访问方式。当是远程请求时，可以通过 此参数，控制 post(默认) 还是get
 */
NW06_gt.prototype.jiazaiPZ = function (dizhi_dx, fwfs) {
    if (typeof dizhi_dx == "object") {
        this.pz = dizhi_dx;
        this._03yc_qq_cg(this.pz);
    } else {
        if (!fwfs) {
            fwfs = 'post';
        }
        if (fwfs == 'post') {
            this.nw.ff.yc.by_j(dizhi_dx, null, this)
        } else {
            this.nw.ff.yc.n_j(dizhi_dx, null, this)
        }
    }
}

//远程加载到的配置文件.开始初始化
NW06_gt.prototype._03yc_qq_cg = function (jg) {
    if (!jg) {
        return;
    }
    this.pz = jg;
    let gt = jg[this.yc_shuju_gt];
    let kjpz;
    let kjlx;

    let kjJD;
    if (gt) {
        for (let i = 0; i < gt.length; i++) {
            kjpz = gt[i];   //找到控件配置了
            kjlx = this._ngj_hqJKlx_tgMC(kjpz.bh);
            kjJD = this._ngj_hqJD_tgMC(kjpz.bh, kjlx)
            if (kjJD) {
                this.kjM.push(new NW06_kj_gt(this, kjJD, kjlx, kjpz))
            }
        }
    }
    this.sj = new NW06_gt_sj(this);
    // this.zdc.xs()
}

/**
 * 内工具，通过名称，取得指定范围内的 节点的类型。
 * @param {文本} mc 节点名称
 * @returns 节点类型|null————没找到节点时类型或不支持该类型
 */
NW06_gt.prototype._ngj_hqJKlx_tgMC = function (mc) {
    let ez1;
    let kjlx;
    for (let i = 0; i < this.jdM.length; i++) {
        ez1 = this.jdM[i];
        if (this._ngj_hqMC(ez1) == mc) {
            kjlx = this._ngj_hqKJlx(ez1);
            if (kjlx) {
                return kjlx;
            }
        }
    }
    return null;
}

/**
 * 内工具，通过名称，取得指定范围内的 节点
 * @param {文本} mc 节点名称
 * @param {文本} lx 节点类型
 * @returns 节点|节点数组|null————没找到节点时
 */
NW06_gt.prototype._ngj_hqJD_tgMC = function (mc, lx) {
    let jg = [];
    let ez1;
    for (let i = 0; i < this.jdM.length; i++) {
        ez1 = this.jdM[i];
        if (this._ngj_hqMC(ez1) == mc) {
            if (lx == 'fxk' || lx == 'dxk') {
                jg.push(ez1);
            } else {
                return this.nw.cj2(ez1);
            }
        }
    }
    return jg.length == 0 ? null : jg;
}

/**
 * 获取控件类型
 * @param {对象} jd 节点
 * @returns 控件类型
 */
NW06_gt.prototype._ngj_hqKJlx = function (jd) {
    switch (jd.nodeName) {
        //value 输入类型的控件
        case 'INPUT':
            let _sx = jd.getAttributeNode('type');
            if (!_sx) {
                return 'wb';
            }
            switch (_sx.value.toLowerCase()) {
                case 'hidden'://文本类型
                case 'text'://文本类型
                    return 'wb';
                case 'file'://文件类型
                    return 'wj';
                case 'checkbox':
                    return 'fxk';
                case 'radio':
                    return 'dxk';
                case 'image':
                    return 'tp';
            }
            return null;
        case 'TEXTAREA':
            return 'wby';
        case 'IMG':
            return 'tp';
        case 'AUDIO':
            return 'yp';
        case 'SELECT':
            return 'xlk';
    }
    //取不到类型的，表示不支持的控件
    return null;
}

/**
 * 通过递归获取 表单控件
 * @param {对象} jd 节点
 */
NW06_gt.prototype._ngj_hqKJ = function (jd) {
    let _ErziM = jd.children;
    for (let i = 0; i < _ErziM.length; i++) {
        switch (_ErziM[i].nodeName) {
            case 'fjcs':
            case 'PZ':
                continue;
            case 'AJ':
            case 'BUTTON':
            case 'INPUT':
            case 'TEXTAREA':
            case 'IMG':
            case 'AUDIO':
            case 'SELECT':
                this.jdM.push(_ErziM[i]);
                continue;
        }
        this._ngj_hqKJ(_ErziM[i]);//检测他的儿子.
    }
}

/**
 * 获取 节点的【名称属性】
 * @param {对象} jd 原始节点
 * @returns 属性
 */
NW06_gt.prototype._ngj_hqMCSX = function (jd) {
    let _sx = jd.getAttributeNode('name');
    if (!_sx) {
        _sx = jd.getAttributeNode('mc');
    }
    return _sx;
}



/**
 * 获取 节点的【属性值】
 * @param {对象} jd 原始节点
 * @returns 属性
 */
NW06_gt.prototype._ngj_hqSXzhi = function (ming) {
    let _sx = this.jd.getAttributeNode(ming);
    if (_sx) {
        return NWHS_sck(_sx.value)
    }
    return null;
}

/**
 * 获取 节点的 名字-自动除两边空。
 * @param {对象} jd 原始节点
 * @returns 名字-自动除两边空。
 */
NW06_gt.prototype._ngj_hqMC = function (jd) {
    let _sx = this._ngj_hqMCSX(jd)
    return _sx ? NWHS_sck(_sx.value) : '';
}

NW06_gt.prototype.hqZnbd = function () {
    return this._ngj_hqSXzhi('znbd');
    // let _sx = this.jd.getAttributeNode('znbd');
    // if (_sx) {
    //     return NWHS_sck(_sx.value)
    // }
    // return null
}
